#include "DetourTileCache.h"
#ifdef __cplusplus
extern "C" {
#endif
void nav_dtCompressedTile_Delete(dtCompressedTile * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtCompressedTile_DeleteArray(dtCompressedTile * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtCompressedTile * nav_NewdtCompressedTile(){
	dtCompressedTile* wrap_out = new dtCompressedTile();
	return wrap_out;
}

unsigned char * * nav_dtCompressedTile_GetPtrToCompressed(dtCompressedTile * c_this){
	return (unsigned char * *)(&(c_this->compressed));
}

int * nav_dtCompressedTile_GetPtrToCompressedSize(dtCompressedTile * c_this){
	return (int *)(&(c_this->compressedSize));
}

unsigned char * * nav_dtCompressedTile_GetPtrToData(dtCompressedTile * c_this){
	return (unsigned char * *)(&(c_this->data));
}

int * nav_dtCompressedTile_GetPtrToDataSize(dtCompressedTile * c_this){
	return (int *)(&(c_this->dataSize));
}

unsigned int * nav_dtCompressedTile_GetPtrToFlags(dtCompressedTile * c_this){
	return (unsigned int *)(&(c_this->flags));
}

dtTileCacheLayerHeader * * nav_dtCompressedTile_GetPtrToHeader(dtCompressedTile * c_this){
	return (dtTileCacheLayerHeader * *)(&(c_this->header));
}

dtCompressedTile * * nav_dtCompressedTile_GetPtrToNext(dtCompressedTile * c_this){
	return (dtCompressedTile * *)(&(c_this->next));
}

unsigned int * nav_dtCompressedTile_GetPtrToSalt(dtCompressedTile * c_this){
	return (unsigned int *)(&(c_this->salt));
}

dtCompressedTile * nav_dtCompressedTile_IndexArray(dtCompressedTile * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

void nav_dtObstacleBox_Delete(dtObstacleBox * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtObstacleBox_DeleteArray(dtObstacleBox * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtObstacleBox * nav_NewdtObstacleBox(){
	dtObstacleBox* wrap_out = new dtObstacleBox();
	return wrap_out;
}

float(*nav_dtObstacleBox_GetPtrToBmax(dtObstacleBox * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_dtObstacleBox_GetPtrToBmin(dtObstacleBox * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

dtObstacleBox * nav_dtObstacleBox_IndexArray(dtObstacleBox * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

void nav_dtObstacleCylinder_Delete(dtObstacleCylinder * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtObstacleCylinder_DeleteArray(dtObstacleCylinder * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtObstacleCylinder * nav_NewdtObstacleCylinder(){
	dtObstacleCylinder* wrap_out = new dtObstacleCylinder();
	return wrap_out;
}

float * nav_dtObstacleCylinder_GetPtrToHeight(dtObstacleCylinder * c_this){
	return (float *)(&(c_this->height));
}

float(*nav_dtObstacleCylinder_GetPtrToPos(dtObstacleCylinder * c_this))[3]{
	return (float(*)[3])(&(c_this->pos));
}

float * nav_dtObstacleCylinder_GetPtrToRadius(dtObstacleCylinder * c_this){
	return (float *)(&(c_this->radius));
}

dtObstacleCylinder * nav_dtObstacleCylinder_IndexArray(dtObstacleCylinder * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

void nav_dtObstacleOrientedBox_Delete(dtObstacleOrientedBox * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtObstacleOrientedBox_DeleteArray(dtObstacleOrientedBox * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtObstacleOrientedBox * nav_NewdtObstacleOrientedBox(){
	dtObstacleOrientedBox* wrap_out = new dtObstacleOrientedBox();
	return wrap_out;
}

float(*nav_dtObstacleOrientedBox_GetPtrToCenter(dtObstacleOrientedBox * c_this))[3]{
	return (float(*)[3])(&(c_this->center));
}

float(*nav_dtObstacleOrientedBox_GetPtrToHalfExtents(dtObstacleOrientedBox * c_this))[3]{
	return (float(*)[3])(&(c_this->halfExtents));
}

float(*nav_dtObstacleOrientedBox_GetPtrToRotAux(dtObstacleOrientedBox * c_this))[2]{
	return (float(*)[2])(&(c_this->rotAux));
}

dtObstacleOrientedBox * nav_dtObstacleOrientedBox_IndexArray(dtObstacleOrientedBox * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

dtStatus nav_dtTileCache_addBoxObstacle(dtTileCache * c_this,float const * bmin,float const * bmax,dtObstacleRef * result){
	float const * c_arg_bmin=(float const *)(void*)(bmin);
	float const * c_arg_bmax=(float const *)(void*)(bmax);
	dtObstacleRef * c_arg_result=(dtObstacleRef *)(void*)(result);
	dtStatus c_out = c_this->addBoxObstacle(c_arg_bmin,c_arg_bmax,c_arg_result);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_addBoxObstacle11(dtTileCache * c_this,float const * center,float const * halfExtents,float const yRadians,dtObstacleRef * result){
	float const * c_arg_center=(float const *)(void*)(center);
	float const * c_arg_halfExtents=(float const *)(void*)(halfExtents);
	float const c_arg_yRadians=yRadians;
	dtObstacleRef * c_arg_result=(dtObstacleRef *)(void*)(result);
	dtStatus c_out = c_this->addBoxObstacle(c_arg_center,c_arg_halfExtents,c_arg_yRadians,c_arg_result);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_addObstacle(dtTileCache * c_this,float const * pos,float const radius,float const height,dtObstacleRef * result){
	float const * c_arg_pos=(float const *)(void*)(pos);
	float const c_arg_radius=radius;
	float const c_arg_height=height;
	dtObstacleRef * c_arg_result=(dtObstacleRef *)(void*)(result);
	dtStatus c_out = c_this->addObstacle(c_arg_pos,c_arg_radius,c_arg_height,c_arg_result);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_addTile(dtTileCache * c_this,unsigned char * data,int const dataSize,unsigned char flags,dtCompressedTileRef * result){
	unsigned char * c_arg_data=(unsigned char *)(void*)(data);
	int const c_arg_dataSize=dataSize;
	unsigned char c_arg_flags=flags;
	dtCompressedTileRef * c_arg_result=(dtCompressedTileRef *)(void*)(result);
	dtStatus c_out = c_this->addTile(c_arg_data,c_arg_dataSize,c_arg_flags,c_arg_result);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_buildNavMeshTile(dtTileCache * c_this,dtCompressedTileRef const ref,dtNavMesh * navmesh){
	dtCompressedTileRef const c_arg_ref=ref;
	dtNavMesh * c_arg_navmesh=(dtNavMesh *)(void*)(navmesh);
	dtStatus c_out = c_this->buildNavMeshTile(c_arg_ref,c_arg_navmesh);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_buildNavMeshTilesAt(dtTileCache * c_this,int const tx,int const ty,dtNavMesh * navmesh){
	int const c_arg_tx=tx;
	int const c_arg_ty=ty;
	dtNavMesh * c_arg_navmesh=(dtNavMesh *)(void*)(navmesh);
	dtStatus c_out = c_this->buildNavMeshTilesAt(c_arg_tx,c_arg_ty,c_arg_navmesh);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

void nav_dtTileCache_calcTightTileBounds(dtTileCache const * c_this,dtTileCacheLayerHeader const * header,float * bmin,float * bmax){
	dtTileCacheLayerHeader const * c_arg_header=(dtTileCacheLayerHeader const *)(void*)(header);
	float * c_arg_bmin=(float *)(void*)(bmin);
	float * c_arg_bmax=(float *)(void*)(bmax);
	c_this->calcTightTileBounds(c_arg_header,c_arg_bmin,c_arg_bmax);
}

unsigned int nav_dtTileCache_decodeObstacleIdObstacle(dtTileCache const * c_this,dtObstacleRef ref){
	dtObstacleRef c_arg_ref=ref;
	unsigned int c_out = c_this->decodeObstacleIdObstacle(c_arg_ref);
	unsigned int wrap_out  = (c_out);
	return wrap_out;
}

unsigned int nav_dtTileCache_decodeObstacleIdSalt(dtTileCache const * c_this,dtObstacleRef ref){
	dtObstacleRef c_arg_ref=ref;
	unsigned int c_out = c_this->decodeObstacleIdSalt(c_arg_ref);
	unsigned int wrap_out  = (c_out);
	return wrap_out;
}

unsigned int nav_dtTileCache_decodeTileIdSalt(dtTileCache const * c_this,dtCompressedTileRef ref){
	dtCompressedTileRef c_arg_ref=ref;
	unsigned int c_out = c_this->decodeTileIdSalt(c_arg_ref);
	unsigned int wrap_out  = (c_out);
	return wrap_out;
}

unsigned int nav_dtTileCache_decodeTileIdTile(dtTileCache const * c_this,dtCompressedTileRef ref){
	dtCompressedTileRef c_arg_ref=ref;
	unsigned int c_out = c_this->decodeTileIdTile(c_arg_ref);
	unsigned int wrap_out  = (c_out);
	return wrap_out;
}

void nav_dtTileCache_Delete(dtTileCache * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtTileCache_DeleteArray(dtTileCache * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtTileCache * nav_NewdtTileCache(){
	dtTileCache* wrap_out = new dtTileCache();
	return wrap_out;
}

dtObstacleRef nav_dtTileCache_encodeObstacleId(dtTileCache const * c_this,unsigned int salt,unsigned int it){
	unsigned int c_arg_salt=salt;
	unsigned int c_arg_it=it;
	dtObstacleRef c_out = c_this->encodeObstacleId(c_arg_salt,c_arg_it);
	dtObstacleRef wrap_out  = (c_out);
	return wrap_out;
}

dtCompressedTileRef nav_dtTileCache_encodeTileId(dtTileCache const * c_this,unsigned int salt,unsigned int it){
	unsigned int c_arg_salt=salt;
	unsigned int c_arg_it=it;
	dtCompressedTileRef c_out = c_this->encodeTileId(c_arg_salt,c_arg_it);
	dtCompressedTileRef wrap_out  = (c_out);
	return wrap_out;
}

dtTileCacheAlloc * nav_dtTileCache_getAlloc(dtTileCache * c_this){
	dtTileCacheAlloc * c_out = c_this->getAlloc();
	dtTileCacheAlloc * wrap_out  = (dtTileCacheAlloc *)(void*)(c_out);
	return wrap_out;
}

dtTileCacheCompressor * nav_dtTileCache_getCompressor(dtTileCache * c_this){
	dtTileCacheCompressor * c_out = c_this->getCompressor();
	dtTileCacheCompressor * wrap_out  = (dtTileCacheCompressor *)(void*)(c_out);
	return wrap_out;
}

dtTileCacheObstacle const * nav_dtTileCache_getObstacle(dtTileCache const * c_this,int const i){
	int const c_arg_i=i;
	dtTileCacheObstacle const * c_out = c_this->getObstacle(c_arg_i);
	dtTileCacheObstacle const * wrap_out  = (dtTileCacheObstacle const *)(void*)(c_out);
	return wrap_out;
}

void nav_dtTileCache_getObstacleBounds(dtTileCache const * c_this,dtTileCacheObstacle const * ob,float * bmin,float * bmax){
	dtTileCacheObstacle const * c_arg_ob=(dtTileCacheObstacle const *)(void*)(ob);
	float * c_arg_bmin=(float *)(void*)(bmin);
	float * c_arg_bmax=(float *)(void*)(bmax);
	c_this->getObstacleBounds(c_arg_ob,c_arg_bmin,c_arg_bmax);
}

dtTileCacheObstacle const * nav_dtTileCache_getObstacleByRef(dtTileCache * c_this,dtObstacleRef ref){
	dtObstacleRef c_arg_ref=ref;
	dtTileCacheObstacle const * c_out = c_this->getObstacleByRef(c_arg_ref);
	dtTileCacheObstacle const * wrap_out  = (dtTileCacheObstacle const *)(void*)(c_out);
	return wrap_out;
}

int nav_dtTileCache_getObstacleCount(dtTileCache const * c_this){
	int c_out = c_this->getObstacleCount();
	int wrap_out  = (c_out);
	return wrap_out;
}

dtObstacleRef nav_dtTileCache_getObstacleRef(dtTileCache const * c_this,dtTileCacheObstacle const * obmin){
	dtTileCacheObstacle const * c_arg_obmin=(dtTileCacheObstacle const *)(void*)(obmin);
	dtObstacleRef c_out = c_this->getObstacleRef(c_arg_obmin);
	dtObstacleRef wrap_out  = (c_out);
	return wrap_out;
}

dtTileCacheParams const * nav_dtTileCache_getParams(dtTileCache const * c_this){
	dtTileCacheParams const * c_out = c_this->getParams();
	dtTileCacheParams const * wrap_out  = (dtTileCacheParams const *)(void*)(c_out);
	return wrap_out;
}

dtCompressedTile const * nav_dtTileCache_getTile(dtTileCache const * c_this,int const i){
	int const c_arg_i=i;
	dtCompressedTile const * c_out = c_this->getTile(c_arg_i);
	dtCompressedTile const * wrap_out  = (dtCompressedTile const *)(void*)(c_out);
	return wrap_out;
}

dtCompressedTile * nav_dtTileCache_getTileAt(dtTileCache * c_this,int const tx,int const ty,int const tlayer){
	int const c_arg_tx=tx;
	int const c_arg_ty=ty;
	int const c_arg_tlayer=tlayer;
	dtCompressedTile * c_out = c_this->getTileAt(c_arg_tx,c_arg_ty,c_arg_tlayer);
	dtCompressedTile * wrap_out  = (dtCompressedTile *)(void*)(c_out);
	return wrap_out;
}

dtCompressedTile const * nav_dtTileCache_getTileByRef(dtTileCache const * c_this,dtCompressedTileRef ref){
	dtCompressedTileRef c_arg_ref=ref;
	dtCompressedTile const * c_out = c_this->getTileByRef(c_arg_ref);
	dtCompressedTile const * wrap_out  = (dtCompressedTile const *)(void*)(c_out);
	return wrap_out;
}

int nav_dtTileCache_getTileCount(dtTileCache const * c_this){
	int c_out = c_this->getTileCount();
	int wrap_out  = (c_out);
	return wrap_out;
}

dtCompressedTileRef nav_dtTileCache_getTileRef(dtTileCache const * c_this,dtCompressedTile const * tile){
	dtCompressedTile const * c_arg_tile=(dtCompressedTile const *)(void*)(tile);
	dtCompressedTileRef c_out = c_this->getTileRef(c_arg_tile);
	dtCompressedTileRef wrap_out  = (c_out);
	return wrap_out;
}

int nav_dtTileCache_getTilesAt(dtTileCache const * c_this,int const tx,int const ty,dtCompressedTileRef * tiles,int const maxTiles){
	int const c_arg_tx=tx;
	int const c_arg_ty=ty;
	dtCompressedTileRef * c_arg_tiles=(dtCompressedTileRef *)(void*)(tiles);
	int const c_arg_maxTiles=maxTiles;
	int c_out = c_this->getTilesAt(c_arg_tx,c_arg_ty,c_arg_tiles,c_arg_maxTiles);
	int wrap_out  = (c_out);
	return wrap_out;
}

dtTileCache * nav_dtTileCache_IndexArray(dtTileCache * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

dtStatus nav_dtTileCache_init(dtTileCache * c_this,dtTileCacheParams const * params,dtTileCacheAlloc * talloc,dtTileCacheCompressor * tcomp,dtTileCacheMeshProcess * tmproc){
	dtTileCacheParams const * c_arg_params=(dtTileCacheParams const *)(void*)(params);
	dtTileCacheAlloc * c_arg_talloc=(dtTileCacheAlloc *)(void*)(talloc);
	dtTileCacheCompressor * c_arg_tcomp=(dtTileCacheCompressor *)(void*)(tcomp);
	dtTileCacheMeshProcess * c_arg_tmproc=(dtTileCacheMeshProcess *)(void*)(tmproc);
	dtStatus c_out = c_this->init(c_arg_params,c_arg_talloc,c_arg_tcomp,c_arg_tmproc);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_queryTiles(dtTileCache const * c_this,float const * bmin,float const * bmax,dtCompressedTileRef * results,int * resultCount,int const maxResults){
	float const * c_arg_bmin=(float const *)(void*)(bmin);
	float const * c_arg_bmax=(float const *)(void*)(bmax);
	dtCompressedTileRef * c_arg_results=(dtCompressedTileRef *)(void*)(results);
	int * c_arg_resultCount=(int *)(void*)(resultCount);
	int const c_arg_maxResults=maxResults;
	dtStatus c_out = c_this->queryTiles(c_arg_bmin,c_arg_bmax,c_arg_results,c_arg_resultCount,c_arg_maxResults);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_removeObstacle(dtTileCache * c_this,dtObstacleRef const ref){
	dtObstacleRef const c_arg_ref=ref;
	dtStatus c_out = c_this->removeObstacle(c_arg_ref);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_removeTile(dtTileCache * c_this,dtCompressedTileRef ref,unsigned char * * data,int * dataSize){
	dtCompressedTileRef c_arg_ref=ref;
	unsigned char * * c_arg_data=(unsigned char * *)(void*)(data);
	int * c_arg_dataSize=(int *)(void*)(dataSize);
	dtStatus c_out = c_this->removeTile(c_arg_ref,c_arg_data,c_arg_dataSize);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtTileCache_update(dtTileCache * c_this,float const dt,dtNavMesh * navmesh,bool * upToDate){
	float const c_arg_dt=dt;
	dtNavMesh * c_arg_navmesh=(dtNavMesh *)(void*)(navmesh);
	bool * c_arg_upToDate=(bool *)(void*)(upToDate);
	dtStatus c_out = c_this->update(c_arg_dt,c_arg_navmesh,c_arg_upToDate);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

void nav_dtTileCacheMeshProcess_Delete(dtTileCacheMeshProcess * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtTileCacheMeshProcess_process(dtTileCacheMeshProcess * c_this,dtNavMeshCreateParams * params,unsigned char * polyAreas,unsigned short * polyFlags){
	dtNavMeshCreateParams * c_arg_params=(dtNavMeshCreateParams *)(void*)(params);
	unsigned char * c_arg_polyAreas=(unsigned char *)(void*)(polyAreas);
	unsigned short * c_arg_polyFlags=(unsigned short *)(void*)(polyFlags);
	c_this->process(c_arg_params,c_arg_polyAreas,c_arg_polyFlags);
}

void nav_dtTileCacheObstacle_Delete(dtTileCacheObstacle * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtTileCacheObstacle_DeleteArray(dtTileCacheObstacle * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtTileCacheObstacle * nav_NewdtTileCacheObstacle(){
	dtTileCacheObstacle* wrap_out = new dtTileCacheObstacle();
	return wrap_out;
}

dtTileCacheObstacle * * nav_dtTileCacheObstacle_GetPtrToNext(dtTileCacheObstacle * c_this){
	return (dtTileCacheObstacle * *)(&(c_this->next));
}

unsigned char * nav_dtTileCacheObstacle_GetPtrToNpending(dtTileCacheObstacle * c_this){
	return (unsigned char *)(&(c_this->npending));
}

unsigned char * nav_dtTileCacheObstacle_GetPtrToNtouched(dtTileCacheObstacle * c_this){
	return (unsigned char *)(&(c_this->ntouched));
}

dtCompressedTileRef(*nav_dtTileCacheObstacle_GetPtrToPending(dtTileCacheObstacle * c_this))[8]{
	return (dtCompressedTileRef(*)[8])(&(c_this->pending));
}

unsigned short * nav_dtTileCacheObstacle_GetPtrToSalt(dtTileCacheObstacle * c_this){
	return (unsigned short *)(&(c_this->salt));
}

unsigned char * nav_dtTileCacheObstacle_GetPtrToState(dtTileCacheObstacle * c_this){
	return (unsigned char *)(&(c_this->state));
}

dtCompressedTileRef(*nav_dtTileCacheObstacle_GetPtrToTouched(dtTileCacheObstacle * c_this))[8]{
	return (dtCompressedTileRef(*)[8])(&(c_this->touched));
}

unsigned char * nav_dtTileCacheObstacle_GetPtrToType(dtTileCacheObstacle * c_this){
	return (unsigned char *)(&(c_this->type));
}

dtTileCacheObstacle * nav_dtTileCacheObstacle_IndexArray(dtTileCacheObstacle * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

void nav_dtTileCacheParams_Delete(dtTileCacheParams * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtTileCacheParams_DeleteArray(dtTileCacheParams * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtTileCacheParams * nav_NewdtTileCacheParams(){
	dtTileCacheParams* wrap_out = new dtTileCacheParams();
	return wrap_out;
}

float * nav_dtTileCacheParams_GetPtrToCh(dtTileCacheParams * c_this){
	return (float *)(&(c_this->ch));
}

float * nav_dtTileCacheParams_GetPtrToCs(dtTileCacheParams * c_this){
	return (float *)(&(c_this->cs));
}

int * nav_dtTileCacheParams_GetPtrToHeight(dtTileCacheParams * c_this){
	return (int *)(&(c_this->height));
}

int * nav_dtTileCacheParams_GetPtrToMaxObstacles(dtTileCacheParams * c_this){
	return (int *)(&(c_this->maxObstacles));
}

float * nav_dtTileCacheParams_GetPtrToMaxSimplificationError(dtTileCacheParams * c_this){
	return (float *)(&(c_this->maxSimplificationError));
}

int * nav_dtTileCacheParams_GetPtrToMaxTiles(dtTileCacheParams * c_this){
	return (int *)(&(c_this->maxTiles));
}

float(*nav_dtTileCacheParams_GetPtrToOrig(dtTileCacheParams * c_this))[3]{
	return (float(*)[3])(&(c_this->orig));
}

float * nav_dtTileCacheParams_GetPtrToWalkableClimb(dtTileCacheParams * c_this){
	return (float *)(&(c_this->walkableClimb));
}

float * nav_dtTileCacheParams_GetPtrToWalkableHeight(dtTileCacheParams * c_this){
	return (float *)(&(c_this->walkableHeight));
}

float * nav_dtTileCacheParams_GetPtrToWalkableRadius(dtTileCacheParams * c_this){
	return (float *)(&(c_this->walkableRadius));
}

int * nav_dtTileCacheParams_GetPtrToWidth(dtTileCacheParams * c_this){
	return (int *)(&(c_this->width));
}

dtTileCacheParams * nav_dtTileCacheParams_IndexArray(dtTileCacheParams * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

dtTileCache * nav_dtAllocTileCache(){
	dtTileCache * c_out = dtAllocTileCache();
	dtTileCache * wrap_out  = (dtTileCache *)(void*)(c_out);
	return wrap_out;
}

void nav_dtFreeTileCache(dtTileCache * tc){
	dtTileCache * c_arg_tc=(dtTileCache *)(void*)(tc);
	dtFreeTileCache(c_arg_tc);
}

dtCompressedTile * nav_NewDtCompressedTilePtrArray(long n){
	dtCompressedTile* c_this=new dtCompressedTile[n];
	return c_this;
}

dtObstacleBox * nav_NewDtObstacleBoxPtrArray(long n){
	dtObstacleBox* c_this=new dtObstacleBox[n];
	return c_this;
}

dtObstacleCylinder * nav_NewDtObstacleCylinderPtrArray(long n){
	dtObstacleCylinder* c_this=new dtObstacleCylinder[n];
	return c_this;
}

dtObstacleOrientedBox * nav_NewDtObstacleOrientedBoxPtrArray(long n){
	dtObstacleOrientedBox* c_this=new dtObstacleOrientedBox[n];
	return c_this;
}

dtTileCacheObstacle * nav_NewDtTileCacheObstaclePtrArray(long n){
	dtTileCacheObstacle* c_this=new dtTileCacheObstacle[n];
	return c_this;
}

dtTileCacheParams * nav_NewDtTileCacheParamsPtrArray(long n){
	dtTileCacheParams* c_this=new dtTileCacheParams[n];
	return c_this;
}

dtTileCache * nav_NewDtTileCachePtrArray(long n){
	dtTileCache* c_this=new dtTileCache[n];
	return c_this;
}

#ifdef __cplusplus
}
#endif
